home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 24 / AACD 24.iso / AACD / Utilities / PdaLink / src / PL_ARexx.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-07-17  |  26.2 KB  |  1,031 lines
  1. /**
  2.  * PdaLink -- Connect Palm with Amiga
  3.  *
  4.  * ARexx Interface
  5.  *
  6.  * (C) 1998-2000 Richard Körber <rkoerber@gmx.de>
  7.  *
  8.  *------------------------------------------------------------------
  9.  *
  10.  * This program is free software; you can redistribute it and/or modify
  11.  * it under the terms of the GNU General Public License as published by
  12.  * the Free Software Foundation; either version 2 of the License, or
  13.  * any later version.
  14.  *
  15.  * This program is distributed in the hope that it will be useful,
  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  * GNU General Public License for more details.
  19.  *
  20.  * You should have received a copy of the GNU General Public License
  21.  * along with this program; if not, write to the Free Software
  22.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23.  *
  24.  * You must not use this source code to gain profit of any kind!
  25.  */
  26.  
  27.  
  28. #include <stdio.h>
  29. #include <string.h>
  30. #include "pdalink_glob.h"
  31.  
  32. #define ARG3(rmp) (rmp->rm_Args[3])    /* Extension to rexx/storage.h */
  33.  
  34.  
  35. static struct TrackArgs
  36. {
  37.   struct RDArgs *rdargs;
  38.   unsigned char param[0];
  39. };
  40.  
  41. /*----------------------------------------------------------------
  42. ** parseArgs    Parse Parameter String                 LOCAL
  43. //>
  44. */
  45. struct TrackArgs *parseArgs(STRPTR param, STRPTR template, LONG *array)
  46. {
  47.   struct TrackArgs *targ;
  48.  
  49.   if(targ = AllocVec(sizeof(struct TrackArgs) + strlen(param) + 5, MEMF_PUBLIC|MEMF_CLEAR))
  50.   {
  51.     if(targ->rdargs = AllocDosObject(DOS_RDARGS,NULL))
  52.     {
  53.       strcpy(targ->param, (param ? param : (STRPTR) "") );
  54.       strcat(targ->param, "\n");
  55.       targ->rdargs->RDA_Flags |= RDAF_NOPROMPT;
  56.       targ->rdargs->RDA_Source.CS_Buffer = targ->param;
  57.       targ->rdargs->RDA_Source.CS_Length = strlen(targ->param);
  58.       if(ReadArgs(template,array,targ->rdargs))
  59.       {
  60.         return(targ);
  61.       }
  62.       FreeDosObject(DOS_RDARGS,targ->rdargs);
  63.     }
  64.     FreeVec(targ);
  65.   }
  66.   return(NULL);
  67. }
  68. //<
  69. /*----------------------------------------------------------------
  70. ** freeArgs     Free a parameter list                       LOCAL
  71. //>
  72. */
  73. void freeArgs(struct TrackArgs *targ)
  74. {
  75.   if(targ)
  76.   {
  77.     FreeArgs(targ->rdargs);
  78.     FreeDosObject(DOS_RDARGS,targ->rdargs);
  79.     FreeVec(targ);
  80.   }
  81. }
  82. //<
  83. /*----------------------------------------------------------------
  84. ** returnString  Return a String as result                  LOCAL
  85. //>
  86. */
  87. void returnString(struct RexxArg **rxarg, STRPTR string)
  88. {
  89.   *rxarg = (struct RexxArg *)CreateArgstring(string,strlen(string));
  90. }
  91. //<
  92. /*----------------------------------------------------------------
  93. ** returnNum    Return an Integer as result                 LOCAL
  94. //>
  95. */
  96. void returnNum(struct RexxArg **rxarg, LONG num)
  97. {
  98.   unsigned char strbuf[30];
  99.   sprintf(strbuf,"%lu",num);
  100.   returnString(rxarg,strbuf);
  101. }
  102. //<
  103. /*----------------------------------------------------------------
  104. ** setStringVar Set an ARexx variable to a String           LOCAL
  105. //>
  106. */
  107. int setStringVar(struct RexxMsg *msg, STRPTR base, STRPTR var, STRPTR cont)
  108. {
  109.   char *buffer = AllocVec(strlen(base)+strlen(var)+2,MEMF_PUBLIC);    // Get a buffer
  110.   int rc = FALSE;
  111.   if(buffer)
  112.   {
  113.     strcpy(buffer,base);
  114.     strcat(buffer,".");
  115.     strcat(buffer,var);
  116.     rc = !SetRexxVar((struct Message *)msg,buffer,cont,strlen(cont));
  117.     FreeVec(buffer);
  118.   }
  119.   return rc;
  120. }
  121. //<
  122. /*----------------------------------------------------------------
  123. ** setNumVar    Set an ARexx variable to an integer         LOCAL
  124. //>
  125. */
  126. int setNumVar(struct RexxMsg *msg, STRPTR base, STRPTR var, LONG cont)
  127. {
  128.   char numbuffer[20];
  129.   char *buffer = AllocVec(strlen(base)+strlen(var)+2,MEMF_PUBLIC);    // Get a buffer
  130.   int rc = FALSE;
  131.  
  132.   if(buffer)
  133.   {
  134.     strcpy(buffer,base);
  135.     strcat(buffer,".");
  136.     strcat(buffer,var);
  137.     sprintf(numbuffer,"%ld",cont);
  138.     rc = !SetRexxVar((struct Message *)msg,buffer,numbuffer,strlen(numbuffer));
  139.     FreeVec(buffer);
  140.   }
  141.   return rc;
  142. }
  143. //<
  144. /*----------------------------------------------------------------
  145. ** setSysTimeVar  Set ARexx variable to DLP_SysTime         LOCAL
  146. //>
  147. */
  148. int setSysTimeVar(struct RexxMsg *msg, STRPTR base, STRPTR var, struct DLP_SysTime *time)
  149. {
  150.   char timebuf[50];
  151.  
  152.   if(time->year==0)
  153.     strcpy(timebuf,"---");
  154.   else
  155.     sprintf(timebuf,"%04ld-%02ld-%02ld %02ld:%02ld:%02ld",time->year,time->month,time->day,time->hour,time->minute,time->second);
  156.   return setStringVar(msg,base,var,timebuf);
  157. }
  158. //<
  159. /*----------------------------------------------------------------
  160. ** setIDVar     Set ARexx variable to an ID                 LOCAL
  161. //>
  162. */
  163. int setIDVar(struct RexxMsg *msg, STRPTR base, STRPTR var, ULONG id)
  164. {
  165.   char idbuf[5];
  166.  
  167.   idbuf[0] = (id>>24)&0xFF;
  168.   idbuf[1] = (id>>16)&0xFF;
  169.   idbuf[2] = (id>>8)&0xFF;
  170.   idbuf[3] = id&0xFF;
  171.   idbuf[4] = 0x00;
  172.   return setStringVar(msg,base,var,idbuf);
  173. }
  174. //<
  175.  
  176.  
  177. /*------------------------------------------------------**
  178. ** Name:        PL_AddRexxHandle                  PUBLIC
  179. **
  180. ** Funktion:    Fügt einen RexxHandle in die Liste ein
  181. **
  182. ** Parameter:   name      Name des Handles (case Sensitive)
  183. **              handle    Handle
  184. ** Ergebnis:
  185. //>
  186. ** Bemerkungen:
  187. **
  188. ** Revision:    29. Oktober 1998, 23:05:17
  189. */
  190. __saveds __asm void PL_AddRexxHandle
  191. (
  192.   register __a0 APTR handle,
  193.   register __a1 STRPTR name
  194. )
  195. {
  196.   struct RexxHandle *newHandle;
  197.  
  198.   ObtainSemaphore(&global.rexxHandleSemaphore);         // obtain a semaphore
  199.   newHandle = AllocVec(sizeof(struct RexxHandle) + strlen(name) + 1 , MEMF_PUBLIC|MEMF_CLEAR);
  200.   if(newHandle)                                         // create structure
  201.   {
  202.     newHandle->rh_node.ln_Name = newHandle->rh_name;    // set ln_Name
  203.     strcpy(newHandle->rh_name,name);                    // copy the name
  204.     newHandle->rh_handle = handle;                      // and the handle
  205.     AddTail(&global.rexxHandles,(struct Node *)newHandle);
  206.   }
  207.   ReleaseSemaphore(&global.rexxHandleSemaphore);
  208. }
  209. //<
  210. /*------------------------------------------------------**
  211. ** Name:        PL_FindRexxHandle                 PUBLIC
  212. **
  213. ** Funktion:    Sucht einen RexxHandle aus der Liste
  214. **
  215. ** Parameter:   name      Name des Handles (case Sensitive)
  216. ** Ergebnis:    handle    Handle
  217. //>
  218. ** Bemerkungen:
  219. **
  220. ** Revision:    29. Oktober 1998, 23:10:06
  221. */
  222. __saveds __asm APTR PL_FindRexxHandle
  223. (
  224.   register __a0 STRPTR name
  225. )
  226. {
  227.   struct RexxHandle *handle;
  228.   APTR plh = NULL;
  229.  
  230.   ObtainSemaphore(&global.rexxHandleSemaphore);         // obtain semaphore
  231.   handle = (struct RexxHandle *)FindName(&global.rexxHandles,name);
  232.   if(handle)
  233.     plh = handle->rh_handle;
  234.   ReleaseSemaphore(&global.rexxHandleSemaphore);
  235.   return(plh);
  236. }
  237. //<
  238. /*------------------------------------------------------**
  239. ** Name:        PL_DeleteRexxHandle               PUBLIC
  240. **
  241. ** Funktion:    Entfernt einen RexxHandle aus der Liste
  242. **
  243. ** Parameter:   name      Name des Handles (case Sensitive)
  244. ** Ergebnis:
  245. //>
  246. ** Bemerkungen:
  247. **
  248. ** Revision:    29. Oktober 1998, 23:11:31
  249. */
  250. __saveds __asm void PL_DeleteRexxHandle
  251. (
  252.   register __a0 STRPTR name
  253. )
  254. {
  255.   struct RexxHandle *handle;
  256.  
  257.   ObtainSemaphore(&global.rexxHandleSemaphore);         // obtain semaphore
  258.   handle = (struct RexxHandle *)FindName(&global.rexxHandles,name);
  259.   if(handle)
  260.   {
  261.     Remove((struct Node *)handle);
  262.     FreeVec(handle);
  263.   }
  264.   ReleaseSemaphore(&global.rexxHandleSemaphore);
  265. }
  266. //<
  267.  
  268. /**
  269.  * Open a socket
  270.  */
  271. static LONG rx_openSocket(struct RexxMsg *rxmsg, struct RexxArg **rxarg)
  272. //>
  273. {
  274.   static STRPTR template = "SD=DEVICE/K,SU=UNIT/K/N,SB=MAXBAUD/K/N";
  275.   struct Parameter
  276.   {
  277.     STRPTR device;
  278.     LONG   *unit;
  279.     LONG   *baud;
  280.   } param = {0};
  281.   struct TrackArgs *targ;
  282.   APTR handle;
  283.   LONG error;
  284.   ULONG tags[20];
  285.   int i = 0;
  286.  
  287.   if(!ARG1(rxmsg)) return(ERR10_017);           /*  wrong number of arguments   */
  288.  
  289.   if(targ = parseArgs(ARG2(rxmsg),template,(LONG *)¶m))
  290.   {
  291.     tags[i++] = PLTAG_ErrorPtr;
  292.     tags[i++] = (ULONG) &error;
  293.     if(param.device)
  294.     {
  295.       tags[i++] = PLTAG_SerialDevice;
  296.       tags[i++] = (ULONG) param.device;
  297.     }
  298.     if(param.unit)
  299.     {
  300.       tags[i++] = PLTAG_SerialUnit;
  301.       tags[i++] = (ULONG) *param.unit;
  302.     }
  303.     if(param.baud)
  304.     {
  305.       tags[i++] = PLTAG_SerialMaxRate;
  306.       tags[i++] = (ULONG) *param.baud;
  307.     }
  308.     tags[i] = TAG_DONE;
  309.  
  310.     handle = PL_OpenSocket((struct TagItem *)tags);
  311.  
  312.     rxmsg->rm_Result1 = error;
  313.  
  314.     PL_AddRexxHandle(handle,ARG1(rxmsg));
  315.  
  316.     freeArgs(targ);
  317.     return(0);
  318.   }
  319.   return(ERR10_018);                          /*  invalid argument to function*/
  320. }
  321. //<
  322.  
  323. /**
  324.  * Close a socket
  325.  */
  326. static LONG rx_closeSocket(struct RexxMsg *rxmsg, struct RexxArg **rxarg)
  327. //>
  328. {
  329.   APTR socket;
  330.  
  331.   if(!ARG1(rxmsg)) return(ERR10_017);         /*  wrong number of arguments   */
  332.   socket = PL_FindRexxHandle(ARG1(rxmsg));
  333.   if(!socket) return(ERR10_018);              /*  invalid argument to function*/
  334.  
  335.   PL_DeleteRexxHandle(ARG1(rxmsg));
  336.   PL_CloseSocket(socket);
  337.   return(0);
  338. }
  339. //<
  340.  
  341. /**
  342.  * Accept a connection
  343.  */
  344. static LONG rx_accept(struct RexxMsg *rxmsg, struct RexxArg **rxarg)
  345. //>
  346. {
  347.   static STRPTR template = "TIMEOUT/K/N";
  348.   struct Parameter
  349.   {
  350.     LONG   *timeout;
  351.   } param = {0};
  352.   struct TrackArgs *targ;
  353.   APTR socket;
  354.   LONG to = 30;             // default to 30 Seconds Timeout
  355.  
  356.   if(!ARG1(rxmsg)) return(ERR10_017);         /*  wrong number of arguments   */
  357.   socket = PL_FindRexxHandle(ARG1(rxmsg));
  358.   if(!socket) return(ERR10_018);              /*  invalid argument to function*/
  359.  
  360.   if(targ = parseArgs(ARG2(rxmsg),template,(LONG *)¶m))
  361.   {
  362.     if(param.timeout) to = *param.timeout;
  363.     if(!PL_Accept(socket,to))
  364.       rxmsg->rm_Result1 = PL_LastError(socket);
  365.  
  366.     freeArgs(targ);
  367.     return(0);
  368.   }
  369.   return(ERR10_018);                          /*  invalid argument to function*/
  370. }
  371. //<
  372.  
  373. /**
  374.  * Open Conduit
  375.  */
  376. static LONG rx_openConduit(struct RexxMsg *rxmsg, struct RexxArg **rxarg)
  377. //>
  378. {
  379.   APTR socket;
  380.  
  381.   if(!ARG1(rxmsg)) return(ERR10_017);         /*  wrong number of arguments   */
  382.   socket = PL_FindRexxHandle(ARG1(rxmsg));
  383.   if(!socket) return(ERR10_018);              /*  invalid argument to function*/
  384.  
  385.   if(!DLP_OpenConduit(socket))
  386.     rxmsg->rm_Result1 = PL_LastError(socket);
  387.  
  388.   return(0);
  389. }
  390. //<
  391.  
  392. /**
  393.  * Close Conduit
  394.  */
  395. static LONG rx_endOfSync(struct RexxMsg *rxmsg, struct RexxArg **rxarg)
  396. //>
  397. {
  398.   static STRPTR template = "STATUS/N";
  399.   struct Parameter
  400.   {
  401.     LONG  *status;
  402.   } param = {0};
  403.   struct TrackArgs *targ;
  404.   APTR socket;
  405.  
  406.   if(!ARG1(rxmsg)) return(ERR10_017);         /*  wrong number of arguments   */
  407.   socket = PL_FindRexxHandle(ARG1(rxmsg));
  408.   if(!socket) return(ERR10_018);              /*  invalid argument to function*/
  409.  
  410.   if(targ = parseArgs(ARG2(rxmsg),template,(LONG *)¶m))
  411.   {
  412.     LONG status = 0;
  413.     if(param.status) status = *param.status;
  414.  
  415.     if(!DLP_EndOfSync(socket,status))
  416.       rxmsg->rm_Result1 = PL_LastError(socket);
  417.  
  418.     freeArgs(targ);
  419.     return(0);
  420.   }
  421.   return(ERR10_018);                          /*  invalid argument to function*/
  422. }
  423. //<
  424.  
  425. /**
  426.  * Add entry to HotSync Log
  427.  */
  428. static LONG rx_addSyncLogEntry(struct RexxMsg *rxmsg, struct RexxArg **rxarg)
  429. //>
  430. {
  431.   LONG rc=0;
  432.   static STRPTR template = "ENTRY/A,NOLF/S";
  433.   struct Parameter
  434.   {
  435.     STRPTR  entry;
  436.     LONG    nolf;
  437.   } param = {0};
  438.   struct TrackArgs *targ;
  439.   APTR socket;
  440.  
  441.   if(!ARG1(rxmsg)) return(ERR10_017);         /*  wrong number of arguments   */
  442.   socket = PL_FindRexxHandle(ARG1(rxmsg));
  443.   if(!socket) return(ERR10_018);              /*  invalid argument to function*/
  444.  
  445.   if(targ = parseArgs(ARG2(rxmsg),template,(LONG *)¶m))
  446.   {
  447.     char *buf = AllocVec(strlen(param.entry)+2,MEMF_PUBLIC);
  448.     if(buf)
  449.     {
  450.       strcpy(buf,param.entry);
  451.       if(!param.nolf) strcat(buf,"\n");
  452.       if(!DLP_AddSyncLogEntry(socket,buf))
  453.         rxmsg->rm_Result1 = PL_LastError(socket);
  454.       FreeVec(buf);
  455.     }
  456.     else
  457.       rc = ERR10_003;                         /* no memory available */
  458.  
  459.     freeArgs(targ);
  460.     return(rc);
  461.   }
  462.   return(ERR10_018);                          /*  invalid argument to function*/
  463. }
  464. //<
  465.  
  466. /**
  467.  * Read information about database
  468.  */
  469. static LONG rx_getDBInfo(struct RexxMsg *rxmsg, struct RexxArg **rxarg)
  470. //>
  471. {
  472.   static STRPTR template = "INDEX/N/A,ROM/S,CARD/K/N";
  473.   struct Parameter
  474.   {
  475.     LONG   *index;
  476.     LONG   rom;
  477.     LONG   *card;
  478.   } param = {0};
  479.   struct TrackArgs *targ;
  480.   APTR socket;
  481.  
  482.   if(!ARG3(rxmsg)) return(ERR10_017);         /*  wrong number of arguments   */
  483.   socket = PL_FindRexxHandle(ARG1(rxmsg));
  484.   if(!socket) return(ERR10_018);              /*  invalid argument to function*/
  485.  
  486.   if(targ = parseArgs(ARG2(rxmsg),template,(LONG *)¶m))
  487.   {
  488.     struct DLP_DBInfo info;
  489.     UBYTE cardno = 0;
  490.     UBYTE flags  = DLPGDBF_RAM;
  491.     char name[36];
  492.  
  493.     if(param.card) cardno = *param.card;
  494.     if(param.rom)  flags  = DLPGDBF_ROM;
  495.  
  496.     if(DLP_GetDBInfo(socket,cardno,flags,*param.index,&info))
  497.     {
  498.       stccpy       (name,info.name,34);
  499.       setStringVar (rxmsg,ARG3(rxmsg),"NAME"      ,name);
  500.       setNumVar    (rxmsg,ARG3(rxmsg),"INDEX"     ,info.index);
  501.       setSysTimeVar(rxmsg,ARG3(rxmsg),"CREATED"   ,&info.createDate);
  502.       setSysTimeVar(rxmsg,ARG3(rxmsg),"MODIFIED"  ,&info.modifyDate);
  503.       setSysTimeVar(rxmsg,ARG3(rxmsg),"BACKUPPED" ,&info.backupDate);
  504.       setNumVar    (rxmsg,ARG3(rxmsg),"VERSION"   ,info.version);
  505.       setIDVar     (rxmsg,ARG3(rxmsg),"CREATOR"   ,info.creator);
  506.       setIDVar     (rxmsg,ARG3(rxmsg),"TYPE"      ,info.type);
  507.       setNumVar    (rxmsg,ARG3(rxmsg),"FLAGS"     ,info.flags);
  508.       setNumVar    (rxmsg,ARG3(rxmsg),"EXCLUDE"   ,info.excludes);
  509.  
  510.       returnNum(rxarg,info.more);
  511.     }
  512.     else
  513.       rxmsg->rm_Result1 = PL_LastError(socket);
  514.  
  515.     freeArgs(targ);
  516.     return(0);
  517.   }
  518.   return(ERR10_018);                          /*  invalid argument to function*/
  519. }
  520. //<
  521.  
  522. /**
  523.  * Read the current baud rate
  524.  */
  525. static LONG rx_getBaudRate(struct RexxMsg *rxmsg, struct RexxArg **rxarg)
  526. //>
  527. {
  528.   APTR socket;
  529.   ULONG rate;
  530.  
  531.   if(!ARG1(rxmsg)) return(ERR10_017);         /*  wrong number of arguments   */
  532.   socket = PL_FindRexxHandle(ARG1(rxmsg));
  533.   if(!socket) return(ERR10_018);              /*  invalid argument to function*/
  534.  
  535.   rate = PL_GetBaudRate(socket);
  536.   returnNum(rxarg,rate);
  537.   return(0);
  538. }
  539. //<
  540.  
  541. /**
  542.  * Read the last error code
  543.  */
  544. static LONG rx_lastError(struct RexxMsg *rxmsg, struct RexxArg **rxarg)
  545. //>
  546. {
  547.   APTR socket;
  548.   LONG ec;
  549.  
  550.   if(!ARG1(rxmsg)) return(ERR10_017);         /*  wrong number of arguments   */
  551.   socket = PL_FindRexxHandle(ARG1(rxmsg));
  552.   if(!socket) return(ERR10_018);              /*  invalid argument to function*/
  553.  
  554.   ec = PL_LastError(socket);
  555.   returnNum(rxarg,ec);
  556.   return(0);
  557. }
  558. //<
  559.  
  560. /**
  561.  * Explains an error code
  562.  */
  563. static LONG rx_explain(struct RexxMsg *rxmsg, struct RexxArg **rxarg)
  564. //>
  565. {
  566.   static STRPTR template = "CODE/N/A";
  567.   struct Parameter
  568.   {
  569.     LONG   *code;
  570.   } param = {0};
  571.   struct TrackArgs *targ;
  572.   APTR socket;
  573.   char buffer[100];
  574.  
  575.   if(!ARG1(rxmsg)) return(ERR10_017);         /*  wrong number of arguments   */
  576.   socket = PL_FindRexxHandle(ARG1(rxmsg));
  577.   if(!socket) return(ERR10_018);              /*  invalid argument to function*/
  578.  
  579.   if(targ = parseArgs(ARG2(rxmsg),template,(LONG *)¶m))
  580.   {
  581.     PL_Explain(*param.code,buffer,100);
  582.     returnString(rxarg,buffer);
  583.  
  584.     freeArgs(targ);
  585.     return(0);
  586.   }
  587.   return(ERR10_018);                          /*  invalid argument to function*/
  588. }
  589. //<
  590.  
  591. /**
  592.  * Reset system
  593.  */
  594. static LONG rx_resetSystem(struct RexxMsg *rxmsg, struct RexxArg **rxarg)
  595. //>
  596. {
  597.   APTR socket;
  598.  
  599.   if(!ARG1(rxmsg)) return(ERR10_017);         /*  wrong number of arguments   */
  600.   socket = PL_FindRexxHandle(ARG1(rxmsg));
  601.   if(!socket) return(ERR10_018);              /*  invalid argument to function*/
  602.  
  603.   if(!DLP_ResetSystem(socket))
  604.     rxmsg->rm_Result1 = PL_LastError(socket);
  605.  
  606.   return(0);
  607. }
  608. //<
  609.  
  610. /**
  611.  * Reset LastSyncPC
  612.  */
  613. static LONG rx_resetLastSyncPC(struct RexxMsg *rxmsg, struct RexxArg **rxarg)
  614. //>
  615. {
  616.   APTR socket;
  617.  
  618.   if(!ARG1(rxmsg)) return(ERR10_017);         /*  wrong number of arguments   */
  619.   socket = PL_FindRexxHandle(ARG1(rxmsg));
  620.   if(!socket) return(ERR10_018);              /*  invalid argument to function*/
  621.  
  622.   if(!DLP_ResetLastSyncPC(socket))
  623.     rxmsg->rm_Result1 = PL_LastError(socket);
  624.  
  625.   return(0);
  626. }
  627. //<
  628.  
  629. /**
  630.  * Changes information about NetSyncInfo
  631.  */
  632. static LONG rx_netSyncInfo(struct RexxMsg *rxmsg, struct RexxArg **rxarg)
  633. //>
  634. {
  635.   static STRPTR template = "LANSYNC/K/N,HOSTNAME/K,HOSTADDRESS/K,HOSTSUBNETMASK/K";
  636.   struct Parameter
  637.   {
  638.     LONG   *lansync;
  639.     STRPTR hostname;
  640.     STRPTR hostaddress;
  641.     STRPTR hostsubnetmask;
  642.   } param = {0};
  643.   struct TrackArgs *targ;
  644.   APTR socket;
  645.   int changed = FALSE;
  646.  
  647.   if(!ARG3(rxmsg)) return(ERR10_017);         /*  wrong number of arguments   */
  648.   socket = PL_FindRexxHandle(ARG1(rxmsg));
  649.   if(!socket) return(ERR10_018);              /*  invalid argument to function*/
  650.  
  651.   if(targ = parseArgs(ARG2(rxmsg),template,(LONG *)¶m))
  652.   {
  653.     struct DLP_NetSyncInfo nsi;
  654.     char buffer[260];
  655.  
  656.     if(DLP_GetNetSyncInfo(socket,&nsi))
  657.     {
  658.       if(param.lansync)
  659.       {
  660.         nsi.lanSync = *param.lansync;
  661.         changed = TRUE;
  662.       }
  663.       if(param.hostname)
  664.       {
  665.         strncpy(nsi.hostName,param.hostname,256);
  666.         changed = TRUE;
  667.       }
  668.       if(param.hostaddress)
  669.       {
  670.         strncpy(nsi.hostAddress,param.hostaddress,40);
  671.         changed = TRUE;
  672.       }
  673.       if(param.hostsubnetmask)
  674.       {
  675.         strncpy(nsi.hostSubnetMask,param.hostsubnetmask,40);
  676.         changed = TRUE;
  677.       }
  678.  
  679.       setNumVar    (rxmsg,ARG3(rxmsg),"LANSYNC"       ,nsi.lanSync);
  680.       stccpy(buffer,nsi.hostName,256);
  681.       setStringVar (rxmsg,ARG3(rxmsg),"HOSTNAME"      ,buffer);
  682.       stccpy(buffer,nsi.hostAddress,40);
  683.       setStringVar (rxmsg,ARG3(rxmsg),"HOSTADDRESS"   ,buffer);
  684.       stccpy(buffer,nsi.hostSubnetMask,40);
  685.       setStringVar (rxmsg,ARG3(rxmsg),"HOSTSUBNETMASK",buffer);
  686.  
  687.       if(changed)
  688.       {
  689.         if(!DLP_SetNetSyncInfo(socket,&nsi))
  690.           rxmsg->rm_Result1 = PL_LastError(socket);
  691.       }
  692.     }
  693.     else
  694.       rxmsg->rm_Result1 = PL_LastError(socket);
  695.  
  696.     freeArgs(targ);
  697.     return(0);
  698.   }
  699.   return(ERR10_018);                          /*  invalid argument to function*/
  700. }
  701. //<
  702.  
  703. /**
  704.  * Change information about UserInfo
  705.  */
  706. static LONG rx_userInfo(struct RexxMsg *rxmsg, struct RexxArg **rxarg)
  707. //>
  708. {
  709.   static STRPTR template = "USERNAME/K,PASSWORD/K";
  710.   struct Parameter
  711.   {
  712.     STRPTR username;
  713.     STRPTR password;
  714.   } param = {0};
  715.   struct TrackArgs *targ;
  716.   APTR socket;
  717.   int changed = FALSE;
  718.  
  719.   if(!ARG3(rxmsg)) return(ERR10_017);         /*  wrong number of arguments   */
  720.   socket = PL_FindRexxHandle(ARG1(rxmsg));
  721.   if(!socket) return(ERR10_018);              /*  invalid argument to function*/
  722.  
  723.   if(targ = parseArgs(ARG2(rxmsg),template,(LONG *)¶m))
  724.   {
  725.     struct DLP_UserInfo ui;
  726.     char buffer[130];
  727.  
  728.     if(DLP_GetUserInfo(socket,&ui))
  729.     {
  730.       if(param.username)
  731.       {
  732.         strncpy(ui.userName,param.username,128);
  733.         changed = TRUE;
  734.       }
  735.  
  736.       if(param.password)
  737.       {
  738.         strncpy(ui.password,param.password,128);
  739.         changed = TRUE;
  740.       }
  741.  
  742.       setIDVar     (rxmsg,ARG3(rxmsg),"USERID"        ,ui.userID);
  743.       setIDVar     (rxmsg,ARG3(rxmsg),"VIEWERID"      ,ui.viewerID);
  744.       setNumVar    (rxmsg,ARG3(rxmsg),"LASTSYNCPC"    ,ui.lastSyncPC);
  745.       setSysTimeVar(rxmsg,ARG3(rxmsg),"LASTSYNC"      ,&ui.lastSync);
  746.       setSysTimeVar(rxmsg,ARG3(rxmsg),"SUCCESSFULSYNC",&ui.successfulSync);
  747.       stccpy(buffer,ui.userName,128);
  748.       setStringVar (rxmsg,ARG3(rxmsg),"USERNAME"      ,buffer);
  749.       stccpy(buffer,ui.password,128);
  750.       setStringVar (rxmsg,ARG3(rxmsg),"PASSWORD"      ,buffer);
  751.  
  752.       if(changed)
  753.       {
  754.         if(!DLP_SetUserInfo(socket,&ui))
  755.           rxmsg->rm_Result1 = PL_LastError(socket);
  756.       }
  757.     }
  758.     else
  759.       rxmsg->rm_Result1 = PL_LastError(socket);
  760.  
  761.     freeArgs(targ);
  762.     return(0);
  763.   }
  764.   return(ERR10_018);                          /*  invalid argument to function*/
  765. }
  766. //<
  767.  
  768. /**
  769.  * Change system time
  770.  */
  771. static LONG rx_sysTime(struct RexxMsg *rxmsg, struct RexxArg **rxarg)
  772. //>
  773. {
  774.   static STRPTR template = "D=DAY/K/N,MO=MONTH/K/N,Y=YEAR/K/N,H=HOUR/K/N,MI=MINUTE/K/N,S=SECOND/K/N";
  775.   struct Parameter
  776.   {
  777.     LONG  *day;
  778.     LONG  *month;
  779.     LONG  *year;
  780.     LONG  *hour;
  781.     LONG  *minute;
  782.     LONG  *second;
  783.   } param = {0};
  784.   struct TrackArgs *targ;
  785.   APTR socket;
  786.   int changed = FALSE;
  787.  
  788.   if(!ARG3(rxmsg)) return(ERR10_017);         /*  wrong number of arguments   */
  789.   socket = PL_FindRexxHandle(ARG1(rxmsg));
  790.   if(!socket) return(ERR10_018);              /*  invalid argument to function*/
  791.  
  792.   if(targ = parseArgs(ARG2(rxmsg),template,(LONG *)¶m))
  793.   {
  794.     struct DLP_SysTime st;
  795.  
  796.     if(DLP_GetSysTime(socket,&st))
  797.     {
  798.       if(param.day)
  799.       {
  800.         LONG day = *param.day;
  801.         if(day>=1 && day<=31)
  802.         {
  803.           st.day = day;
  804.           changed = TRUE;
  805.         }
  806.       }
  807.       if(param.month)
  808.       {
  809.         LONG month = *param.month;
  810.         if(month>=1 && month<=12)
  811.         {
  812.           st.month = month;
  813.           changed = TRUE;
  814.         }
  815.       }
  816.       if(param.year)
  817.       {
  818.         LONG year = *param.year;
  819.         if(year<200) year+=1900;
  820.         st.year = year;
  821.         changed = TRUE;
  822.       }
  823.       if(param.hour)
  824.       {
  825.         LONG hour = *param.hour;
  826.         if(hour>=0 && hour<=23)
  827.         {
  828.           st.hour = hour;
  829.           changed = TRUE;
  830.         }
  831.       }
  832.       if(param.minute)
  833.       {
  834.         LONG minute = *param.minute;
  835.         if(minute>=0 && minute<=59)
  836.         {
  837.           st.minute = minute;
  838.           changed = TRUE;
  839.         }
  840.       }
  841.       if(param.second)
  842.       {
  843.         LONG second = *param.second;
  844.         if(second>=0 && second<=60)        // UTC may have 61 seconds per minute!
  845.         {
  846.           st.second = second;
  847.           changed = TRUE;
  848.         }
  849.       }
  850.  
  851.       setSysTimeVar(rxmsg,ARG3(rxmsg),"TIME"      ,&st);
  852.       setNumVar    (rxmsg,ARG3(rxmsg),"SECOND"    ,st.second);
  853.       setNumVar    (rxmsg,ARG3(rxmsg),"MINUTE"    ,st.minute);
  854.       setNumVar    (rxmsg,ARG3(rxmsg),"HOUR"      ,st.hour);
  855.       setNumVar    (rxmsg,ARG3(rxmsg),"DAY"       ,st.day);
  856.       setNumVar    (rxmsg,ARG3(rxmsg),"MONTH"     ,st.month);
  857.       setNumVar    (rxmsg,ARG3(rxmsg),"YEAR"      ,st.year);
  858.  
  859.       if(changed)
  860.       {
  861.         if(!DLP_SetSysTime(socket,&st))
  862.           rxmsg->rm_Result1 = PL_LastError(socket);
  863.       }
  864.     }
  865.     else
  866.       rxmsg->rm_Result1 = PL_LastError(socket);
  867.  
  868.     freeArgs(targ);
  869.     return(0);
  870.   }
  871.   return(ERR10_018);                          /*  invalid argument to function*/
  872. }
  873. //<
  874.  
  875. /**
  876.  * Read StorageInfo
  877.  */
  878. static LONG rx_getStorageInfo(struct RexxMsg *rxmsg, struct RexxArg **rxarg)
  879. //>
  880. {
  881.   static STRPTR template = "CARD/N";
  882.   struct Parameter
  883.   {
  884.     LONG   *card;
  885.   } param = {0};
  886.   struct TrackArgs *targ;
  887.   APTR socket;
  888.  
  889.   if(!ARG3(rxmsg)) return(ERR10_017);         /*  wrong number of arguments   */
  890.   socket = PL_FindRexxHandle(ARG1(rxmsg));
  891.   if(!socket) return(ERR10_018);              /*  invalid argument to function*/
  892.  
  893.   if(targ = parseArgs(ARG2(rxmsg),template,(LONG *)¶m))
  894.   {
  895.     struct DLP_StorageInfo info;
  896.     UBYTE cardno = 0;
  897.     char name[130];
  898.  
  899.     if(param.card) cardno = *param.card;
  900.  
  901.     if(DLP_GetStorageInfo(socket,cardno,&info))
  902.     {
  903.       stccpy       (name,info.name,128);
  904.       setStringVar (rxmsg,ARG3(rxmsg),"NAME"        ,name);
  905.       stccpy       (name,info.manuf,128);
  906.       setStringVar (rxmsg,ARG3(rxmsg),"MANUFACTURER",name);
  907.       setNumVar    (rxmsg,ARG3(rxmsg),"CARDNO"      ,info.cardNo);
  908.       setNumVar    (rxmsg,ARG3(rxmsg),"VERSION"     ,info.cardVersion);
  909.       setSysTimeVar(rxmsg,ARG3(rxmsg),"CREATED"     ,&info.date);
  910.       setNumVar    (rxmsg,ARG3(rxmsg),"ROMSIZE"     ,info.ROMSize);
  911.       setNumVar    (rxmsg,ARG3(rxmsg),"RAMSIZE"     ,info.RAMSize);
  912.       setNumVar    (rxmsg,ARG3(rxmsg),"RAMFREE"     ,info.RAMFree);
  913.  
  914.       returnNum(rxarg,info.more);
  915.     }
  916.     else
  917.       rxmsg->rm_Result1 = PL_LastError(socket);
  918.  
  919.     freeArgs(targ);
  920.     return(0);
  921.   }
  922.   return(ERR10_018);                          /*  invalid argument to function*/
  923. }
  924. //<
  925.  
  926. /**
  927.  * Read SysInfo
  928.  */
  929. static LONG rx_getSysInfo(struct RexxMsg *rxmsg, struct RexxArg **rxarg)
  930. //>
  931. {
  932.   APTR socket;
  933.   struct DLP_SysInfo info;
  934.  
  935.   if(!ARG2(rxmsg)) return(ERR10_017);         /*  wrong number of arguments   */
  936.   socket = PL_FindRexxHandle(ARG1(rxmsg));
  937.   if(!socket) return(ERR10_018);              /*  invalid argument to function*/
  938.  
  939.   if(DLP_GetSysInfo(socket,&info))
  940.   {
  941.     char name[130];
  942.     stccpy       (name,info.name,128);
  943.     setStringVar (rxmsg,ARG2(rxmsg),"SYSNAME"   ,name);
  944.     setNumVar    (rxmsg,ARG2(rxmsg),"ROMVERSION",info.romVer);
  945.     setNumVar    (rxmsg,ARG2(rxmsg),"LOCALIZION",info.locale);
  946.   }
  947.   else
  948.     rxmsg->rm_Result1 = PL_LastError(socket);
  949.  
  950.   return(0);
  951. }
  952. //<
  953.  
  954.  
  955. /*----------------------------------------------------------------
  956. ** RexxCmd      Rexx command call
  957. //>
  958. */
  959. __saveds __asm LONG RexxCmd
  960. (
  961.   register __a0 struct RexxMsg *rxmsg,
  962.   register __a1 struct RexxArg **rxarg
  963. )
  964. {
  965.   STRPTR cmdstr = ARG0(rxmsg);
  966.  
  967.   // Quick and dirty test
  968.   if(strnicmp(cmdstr,"PDA_",5))
  969.     return(1);
  970.  
  971.   // It is most probably one of our commands, so perform
  972.   // a detailed test.
  973.   /*TODO: speed this up a litte bit, preferably with a nice hash table*/
  974.   if(!stricmp(cmdstr,"PDA_OPENSOCKET"))
  975.     return rx_openSocket(rxmsg,rxarg);
  976.  
  977.   if(!stricmp(cmdstr,"PDA_CLOSESOCKET"))
  978.     return rx_closeSocket(rxmsg,rxarg);
  979.  
  980.   if(!stricmp(cmdstr,"PDA_ACCEPT"))
  981.     return rx_accept(rxmsg,rxarg);
  982.  
  983.   if(!stricmp(cmdstr,"PDA_OPENCONDUIT"))
  984.     return rx_openConduit(rxmsg,rxarg);
  985.  
  986.   if(!stricmp(cmdstr,"PDA_ENDOFSYNC"))
  987.     return rx_endOfSync(rxmsg,rxarg);
  988.  
  989.   if(!stricmp(cmdstr,"PDA_ADDSYNCLOGENTRY"))
  990.     return rx_addSyncLogEntry(rxmsg,rxarg);
  991.  
  992.   if(!stricmp(cmdstr,"PDA_GETDBINFO"))
  993.     return rx_getDBInfo(rxmsg,rxarg);
  994.  
  995.   if(!stricmp(cmdstr,"PDA_LASTERROR"))
  996.     return rx_lastError(rxmsg,rxarg);
  997.  
  998.   if(!stricmp(cmdstr,"PDA_EXPLAIN"))
  999.     return rx_explain(rxmsg,rxarg);
  1000.  
  1001.   if(!stricmp(cmdstr,"PDA_RESETSYSTEM"))
  1002.     return rx_resetSystem(rxmsg,rxarg);
  1003.  
  1004.   if(!stricmp(cmdstr,"PDA_RESETLASTSYNCPC"))
  1005.     return rx_resetLastSyncPC(rxmsg,rxarg);
  1006.  
  1007.   if(!stricmp(cmdstr,"PDA_USERINFO"))
  1008.     return rx_userInfo(rxmsg,rxarg);
  1009.  
  1010.   if(!stricmp(cmdstr,"PDA_SYSTIME"))
  1011.     return rx_sysTime(rxmsg,rxarg);
  1012.  
  1013.   if(!stricmp(cmdstr,"PDA_NETSYNCINFO"))
  1014.     return rx_netSyncInfo(rxmsg,rxarg);
  1015.  
  1016.   if(!stricmp(cmdstr,"PDA_GETSTORAGEINFO"))
  1017.     return rx_getStorageInfo(rxmsg,rxarg);
  1018.  
  1019.   if(!stricmp(cmdstr,"PDA_GETSYSINFO"))
  1020.     return rx_getSysInfo(rxmsg,rxarg);
  1021.  
  1022.   if(!stricmp(cmdstr,"PDA_GETBAUDRATE"))
  1023.     return rx_getBaudRate(rxmsg,rxarg);
  1024.  
  1025.   return(1);                                      // Command not known
  1026. }
  1027. //<
  1028.  
  1029. /****************************************************************/
  1030.  
  1031.